import XLSX from 'xlsx';

// utils/excelUtil.js 中补充完整的 parseExcel 方法
export const excelParseUtil = {
  // 解析Excel文件（前端真实解析）
   parseExcel(file) {
    return new Promise((resolve, reject) => {
      // 1. 双重校验文件对象是否有效
      if (!file || !(file instanceof File)) {
        reject(new Error('未获取到有效文件，请重新上传'));
        return;
      }

      // 2. 校验文件格式（增强容错）
      const fileName = file.name.toLowerCase();
      if (!fileName.endsWith('.xlsx') && !fileName.endsWith('.xls')) {
        reject(new Error('文件格式错误，仅支持.xlsx和.xls格式'));
        return;
      }

      // 3. 正确初始化 FileReader（关键修复点）
      const reader = new FileReader(); // 确保 reader 已实例化

      // 4. 加载成功回调
      reader.onload = (e) => {
        try {
          let workbook;
          // 区分.xls和.xlsx格式读取
          if (fileName.endsWith('.xls')) {
            // .xls 格式：用 binary 方式读取
            workbook = XLSX.read(e.target.result, { type: 'binary' });
          } else {
            // .xlsx 格式：用 array 方式读取
            const data = new Uint8Array(e.target.result);
            workbook = XLSX.read(data, { type: 'array' });
          }

          // 解析第一个工作表
          const worksheet = workbook.Sheets[workbook.SheetNames[0]];
          const result = this.parseWorksheet(worksheet);
          resolve(result);
        } catch (err) {
          reject(new Error(`文件解析失败：${err.message}`));
        }
      };

      // 5. 加载失败回调（新增，捕获读取错误）
      reader.onerror = () => {
        reject(new Error('文件读取失败，请检查文件是否损坏或被占用'));
      };

      // 6. 开始读取文件（确保 reader 存在再调用 read）
      if (fileName.endsWith('.xls')) {
        reader.readAsBinaryString(file); // .xls 用 binary 格式
      } else {
        reader.readAsArrayBuffer(file); // .xlsx 用 arrayBuffer 格式
      }
    });
  },

  // 解析工作表核心逻辑
  parseWorksheet(worksheet) {
    // 解析数据区域（避免无数据时报错）
    const range = worksheet['!ref'] ? XLSX.utils.decode_range(worksheet['!ref']) : {
      s: { r: 0, c: 0 },
      e: { r: 0, c: 0 }
    };
    const startRow = range.s.r + 1;
    const endRow = range.e.r + 1;
    const startCol = range.s.c + 1;
    const endCol = range.e.c + 1;

    // 解析合并单元格
    const merges = this.parseMerges(worksheet['!merges'] || []);

    // 解析单元格内容
    const cells = [];
    for (let r = range.s.r; r <= range.e.r; r++) {
      for (let c = range.s.c; c <= range.e.c; c++) {
        const cellAddress = XLSX.utils.encode_cell({ r, c });
        const cell = worksheet[cellAddress];
        // 处理不同类型的单元格值（数字、文本、日期）
        let cellValue = '';
        if (cell) {
          switch (cell.t) {
            case 'n': // 数字
              cellValue = cell.v.toString();
              break;
            case 's': // 文本
              cellValue = cell.v;
              break;
            case 'd': // 日期
              cellValue = new Date(cell.v).toLocaleDateString();
              break;
            default:
              cellValue = cell.v || '';
          }
        }
        cells.push({
          row: r + 1,
          col: c + 1,
          value: cellValue,
          isEmpty: !cellValue || cellValue === '',
          address: cellAddress
        });
      }
    }

    return {
      startRow,
      endRow,
      startCol,
      endCol,
      cells,
      merges
    };
  },

  // 解析合并单元格（转为1开始的行号列号）
  parseMerges(merges) {
    return merges.map(merge => {
      const start = XLSX.utils.decode_cell(merge.s);
      const end = XLSX.utils.decode_cell(merge.e);
      return {
        row: start.r + 1,
        col: start.c + 1,
        rowspan: end.r - start.r + 1,
        colspan: end.c - start.c + 1
      };
    });
  }
};

/**
 * Excel导出工具
 */
export const excelExportUtil = {
  // 导出Excel模板
  exportExcel({ fileName, cells, merges, paramAssociateRules, colList }) {
    // 创建工作簿
    const workbook = XLSX.utils.book_new();
    // 创建工作表数据
    const worksheetData = this.generateWorksheetData(cells, paramAssociateRules, colList);
    // 创建工作表
    const worksheet = XLSX.utils.aoa_to_sheet(worksheetData);
    // 设置合并单元格
    worksheet['!merges'] = this.formatMerges(merges);
    // 设置列宽
    worksheet['!cols'] = colList.map(col => ({ wpx: col.width || 120 }));
    // 添加工作表到工作簿
    XLSX.utils.book_append_sheet(workbook, worksheet, '模板');
    // 导出文件
    XLSX.writeFile(workbook, fileName);
  },

  // 生成工作表数据（二维数组）
  generateWorksheetData(cells, paramAssociateRules, colList) {
    const maxRow = Math.max(...cells.map(cell => cell.row));
    const maxCol = Math.max(...colList.map(col => col.col));
    // 初始化二维数组
    const data = Array.from({ length: maxRow }, () => Array(maxCol).fill(''));
    // 填充固定文本
    cells.forEach(cell => {
      const rowIndex = cell.row - 1;
      const colIndex = cell.col - 1;
      data[rowIndex][colIndex] = cell.value;
    });
    // 填充参数占位符
    paramAssociateRules.forEach(rule => {
      const rowIndex = rule.cellRow - 1;
      const colIndex = rule.cellCol - 1;
      data[rowIndex][colIndex] = `{{${rule.headerName}}}`;
    });
    return data;
  },

  // 格式化合并单元格（适配xlsx库格式）
  formatMerges(merges) {
    return merges.map(merge => {
      const start = XLSX.utils.encode_cell({ r: merge.row - 1, c: merge.col - 1 });
      const end = XLSX.utils.encode_cell({
        r: merge.row + merge.rowspan - 2,
        c: merge.col + merge.colspan - 2
      });
      return { s: XLSX.utils.decode_cell(start), e: XLSX.utils.decode_cell(end) };
    });
  }
};